home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 23 / CU Amiga - Super CD-ROM 23 (June 1998).iso / CreatingGames / Utilities / C / GBDK / lib / stdio.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-04-16  |  7.0 KB  |  458 lines
  1. #include <stdio.h>
  2. #include <stdarg.h>
  3.  
  4. /* ************************************************************ */
  5.  
  6. int atoi(char *s)
  7. {
  8.   int i, n, sign;
  9.  
  10.   for(i = 0; (s[i] == ' ') || (s[i] == EOL) || (s[i] == '\t'); ++i)
  11.     ;
  12.   sign = 1;
  13.   switch(s[i])
  14.     {
  15.     case '-':
  16.       sign = -1;
  17.       /* and fall through */
  18.     case '+':
  19.       ++i;
  20.       break;
  21.     }
  22.   for(n = 0; isdigit(s[i]); ++i)
  23.     n = 10 * n + s[i] - '0';
  24.   return(sign * n);
  25. }
  26.  
  27. /* ************************************************************ */
  28.  
  29. int abs(int num)
  30. {
  31.   if(num < 0)
  32.     return(-num);
  33.   else
  34.     return(num);
  35. }
  36.  
  37. /* ************************************************************ */
  38.  
  39. int isalpha(char c)
  40. {
  41.   if((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
  42.     return(1);
  43.   else
  44.     return(0);
  45. }
  46.  
  47. int isupper(char c)
  48. {
  49.   if(c >= 'A' && c <= 'Z')
  50.     return(1);
  51.   else
  52.     return(0);
  53. }
  54.  
  55. int islower(char c)
  56. {
  57.   if(c >= 'a' && c <= 'z')
  58.     return(1);
  59.   else
  60.     return(0);
  61. }
  62.  
  63. int isdigit(char c)
  64. {
  65.   if(c >= '0' && c <= '9')
  66.     return(1);
  67.   else
  68.     return(0);
  69. }
  70.  
  71. int isspace(char c)
  72. {
  73.   if(c == ' ' || c == '\t' || c == '\n')
  74.     return(1);
  75.   else
  76.     return(0);
  77. }
  78.  
  79. int toupper(char c)
  80. {
  81.   return((c >= 'a' && c <= 'z') ? c - 32: c);
  82. }
  83.  
  84. int tolower(char c)
  85. {
  86.   return((c >= 'A' && c <= 'Z') ? c + 32: c);
  87. }
  88.  
  89.  
  90. /* ************************************************************ */
  91.  
  92. /* Find index of string t in s */
  93.  
  94. int index(char *s, char *t)
  95. {
  96.   int i, j, k;
  97.  
  98.   for(i = 0; s[i] != EOS; i++) {
  99.     k = 0;
  100.     for(j = i; t[k] != EOS && s[j] == t[k]; i++)
  101.       j++;
  102.     if (t[k] == EOS)
  103.       return(i);
  104.   }
  105.   return(-1);
  106. }
  107.  
  108. /* ************************************************************ */
  109.  
  110. char *itoa(int n, char *s)
  111. {
  112.   int i, sign;
  113.  
  114.   if((sign = n) < 0)
  115.     n = -n;
  116.   i = 0;
  117.   do {
  118.     s[i++] = n % 10 + '0';
  119.   } while((n = n/10) > 0);
  120.   if(sign < 0) s[i++] = '-';
  121.   s[i] = EOS;
  122.   reverse(s);
  123.   return(s);
  124. }
  125.  
  126. /* ************************************************************ */
  127.  
  128. /* Print a number in any radix */
  129.  
  130. #define DIGARR "0123456789ABCDEF"
  131.  
  132. void printn(int number, int radix)
  133. {
  134.   int i;
  135.   char *digitreps;
  136.  
  137.   if(number < 0 && radix == 10) {
  138.     putchar('-');
  139.     number = -number;
  140.   }
  141.   if((i = (unsigned)number / (unsigned)radix) != 0)
  142.     printn(i, radix);
  143.   digitreps = DIGARR;
  144.   putchar(digitreps[(unsigned)number % (unsigned)radix]);
  145. }
  146.  
  147. /* ************************************************************ */
  148.  
  149. /* Reverse a character string */
  150.  
  151. char *reverse(char *s)
  152. {
  153.   int i, j;
  154.   char c;
  155.  
  156.   i = 0;
  157.   j = strlen(s) - 1;
  158.   while(i < j) {
  159.     c = s[i];
  160.     s[i] = s[j];
  161.     s[j] = c;
  162.     i++;
  163.     j--;
  164.   }
  165.   return(s);
  166. }
  167.  
  168. /* ************************************************************ */
  169.  
  170. /*
  171.  * Concatenate s2 on the end of s1. s1 must be large enough.
  172.  * Return s1.
  173.  */
  174.  
  175. char *strcat(char *s1, char *s2)
  176. {
  177.   char *os1;
  178.  
  179.   os1 = s1;
  180.   while(*s1++)
  181.     ;
  182.   *--s1;
  183.   while(*s1++ = *s2++)
  184.     ;
  185.   return(os1);
  186. }
  187.  
  188. /* ************************************************************ */
  189.  
  190. /*
  191.  * Compare strings:
  192.  *  s1>s2: >0
  193.  *  s1==s2: 0
  194.  *  s1<s2: <0
  195.  */
  196.  
  197. int strcmp(char *s1, char *s2)
  198. {
  199.   while(*s1 == *s2++)
  200.     if(*s1++=='\0')
  201.       return(0);
  202.   return(*s1 - *--s2);
  203. }
  204.  
  205. /* ************************************************************ */
  206.  
  207. /*
  208.  * Copy string s2 to s1. s1 must be large enough.
  209.  * Return s1.
  210.  */
  211.  
  212. char *strcpy(char *s1, char *s2)
  213. {
  214.   char *os1;
  215.  
  216.   os1 = s1;
  217.   while(*s1++ = *s2++)
  218.     ;
  219.   return(os1);
  220. }
  221.  
  222. /* ************************************************************ */
  223.  
  224. /* Return length of string */
  225.  
  226. int strlen(char *s)
  227. {
  228.   int i;
  229.  
  230.   i = 0;
  231.   while(*s++)
  232.     i++;
  233.   return(i);
  234. }
  235.  
  236. /* ************************************************************ */
  237.  
  238. /*
  239.  * Concatenate s2 on the end of s1. s1 must be large enough.
  240.  * At most n characters are moved.
  241.  * Return s1.
  242.  */
  243.  
  244. char *strncat(char *s1, char *s2, int n)
  245. {
  246.   char *os1;
  247.  
  248.   os1 = s1;
  249.   while(*s1++)
  250.     ;
  251.   --s1;
  252.   while(*s1++ = *s2++)
  253.     if(--n < 0) {
  254.       *--s1 = '\0';
  255.       break;
  256.     }
  257.   return(os1);
  258. }
  259.  
  260. /* ************************************************************ */
  261.  
  262. /*
  263.  * Compare strings (at most n bytes):
  264.  *  s1>s2: >0
  265.  *  s1==s2: 0
  266.  *  s1<s2: <0
  267.  */
  268.  
  269. int strncmp(char *s1, char *s2, int n)
  270. {
  271.   while(--n >= 0 && *s1 == *s2++)
  272.     if (*s1++ == '\0')
  273.       return(0);
  274.   return(n < 0 ? 0 : *s1 - *--s2);
  275. }
  276.  
  277. /* ************************************************************ */
  278.  
  279. /*
  280.  * Copy s2 to s1, truncating or null-padding to always copy n bytes.
  281.  * Return s1.
  282.  */
  283.  
  284. char *strncpy(char *s1, char *s2, int n)
  285. {
  286.   int i;
  287.   char *os1;
  288.  
  289.   os1 = s1;
  290.   for(i = 0; i < n; i++)
  291.     if((*s1++ = *s2++) == '\0') {
  292.       while(++i < n)
  293.     *s1++ = '\0';
  294.       return(os1);
  295.     }
  296.   return(os1);
  297. }
  298.  
  299. /* ************************************************************ */
  300.  
  301. void puts(char *str)
  302. {
  303.   while (*str)
  304.     putchar(*str++);
  305.   putchar(EOL);
  306. }
  307.  
  308. void print(char *str)
  309. {
  310.   while (*str)
  311.     putchar(*str++);
  312. }
  313.  
  314. /* ************************************************************ */
  315.  
  316. void printf(char *fmt, ...)
  317. {
  318.   va_list ap;
  319.  
  320.   va_start(ap, fmt);
  321.   for (; *fmt; fmt++)
  322.     if (*fmt == '%')
  323.       switch (*++fmt) {
  324.       case 'c':
  325.     /* char */
  326.     putchar(va_arg(ap, int));
  327.     break;
  328.       case 'd':
  329.     /* decimal number */
  330.     printn(va_arg(ap, int), 10);
  331.     break;
  332.       case 'o':
  333.     /* octal number */
  334.     printn(va_arg(ap, int), 8);
  335.     break;
  336.       case 'p':
  337.     /* pointer */
  338.     printn((int)va_arg(ap, void *), 16);
  339.     break;
  340.       case 's':
  341.     /* string */
  342.     print(va_arg(ap, char *));
  343.     break;
  344.       case 'x':
  345.     /* hexadecimal number */
  346.     printn(va_arg(ap, int), 16);
  347.     break;
  348.       default:
  349.     putchar(*fmt);
  350.     break;
  351.       }
  352.     else
  353.       putchar(*fmt);
  354.   va_end(ap);
  355. }
  356.  
  357. /* ************************************************************ */
  358.  
  359. int scan_skip(char *s, int i)
  360. {
  361. oncemore:
  362.   while(isspace(s[i]))
  363.     i++;
  364.   if(s[i] == EOS) {
  365.     gets(s);
  366.     i = 0;
  367.     goto oncemore;
  368.   }
  369.   return i;
  370. }
  371.  
  372. int scan_int(char *s, int i, int base, int *nb)
  373. {
  374.   int n = 0, sign = 1, j;
  375.  
  376.   switch(s[i])
  377.     {
  378.     case '-':
  379.       sign = -1;
  380.       /* and fall through */
  381.     case '+':
  382.       ++i;
  383.       break;
  384.     }
  385.   while(1) {
  386.     if(isdigit(s[i]))
  387.       j = s[i] - '0';
  388.     else if(isalpha(s[i]))
  389.       j = toupper(s[i]) - 'A' + 10;
  390.     else
  391.       break;
  392.     if(j >= base)
  393.       break;
  394.     n = base * n + j;
  395.     i++;
  396.   }
  397.   *nb = sign * n;
  398.   return(i);
  399. }
  400.  
  401. int scanf(char *fmt, ...)
  402. {
  403.   va_list ap;
  404.   char s[64];
  405.   int i = 0, nb = 0;
  406.  
  407.   gets(s);
  408.   va_start(ap, fmt);
  409.   for (; *fmt; fmt++) {
  410.     if(isspace(*fmt))
  411.       continue;
  412.     i = scan_skip(s, i);
  413.     if (*fmt == '%') {
  414.       switch (*++fmt) {
  415.       case 'c':
  416.     /* char */
  417.     *va_arg(ap, char *) = s[i++];
  418.     break;
  419.       case 'd':
  420.     /* decimal number */
  421.     i = scan_int(s, i, 10, va_arg(ap, int *));
  422.     break;
  423.       case 'o':
  424.     /* octal number */
  425.     i = scan_int(s, i, 8, va_arg(ap, int *));
  426.     break;
  427.       case 'p':
  428.     /* pointer */
  429.     i = scan_int(s, i, 16, (int *)va_arg(ap, void **));
  430.     break;
  431.       case 's':
  432.     /* string */
  433.     {
  434.       int j = 0;
  435.       char *d = va_arg(ap, char *);
  436.       while((d[j++] = s[i++]) != EOS)
  437.         ;
  438.     }
  439.     break;
  440.       case 'x':
  441.     /* hexadecimal number */
  442.     i = scan_int(s, i, 16, va_arg(ap, int *));
  443.     break;
  444.       default:
  445.     if(s[i] != *fmt)
  446.       return EOF;
  447.     break;
  448.       }
  449.       nb++;
  450.     } else
  451.       if(s[i] != *fmt)
  452.     return EOF;
  453.   }
  454.   va_end(ap);
  455.  
  456.   return nb;
  457. }
  458.